#include "FrameDeEleccionDeFiltros.h"

FrameDeEleccionDeFiltros::FrameDeEleccionDeFiltros():botonRemoverFiltro(Gtk::Stock::REMOVE),
	botonRemoverInput(Gtk::Stock::REMOVE), botonAgregarDimension(Gtk::Stock::ADD), botonAgregarHecho(Gtk::Stock::ADD) {

	inicializarBotones();
	inicializarCombos();
	inicializarHechos();
	inicializarMeses();
	inicializarVentanasDeslizables();
	iniciarLabels();

	conectarManejadoresDeEvento();
	inicializarCajas();
	add(cajaVertical);
}

void FrameDeEleccionDeFiltros::inicializarCajas() {
	cajaHModoSeleccion.pack_start(labelModoEleccion, false, false, 20);
	cajaHModoSeleccion.pack_start(botonModoEleccion, false, false, 5);	// **

	cajaVWidgetsDimensiones.pack_start(comboDimension, false, false, 25);
	cajaVWidgetsDimensiones.pack_start(botonAgregarDimension, false, false, 5);
	cajaVWidgetsHechos.pack_start(comboHecho, false, false, 25);
	cajaVWidgetsHechos.pack_start(botonAgregarHecho, false, false, 5),

	cajaHDimensionesHechos.pack_start(ventanaDeslizableDimensiones, false, false, 20);
	cajaHDimensionesHechos.pack_start(cajaVWidgetsDimensiones, false, false, 5);
	cajaHDimensionesHechos.pack_start(ventanaDeslizableHechos, false, false, 25);
	cajaHDimensionesHechos.pack_start(cajaVWidgetsHechos, false, false, 5);	// **

	cajaHFecha.pack_start(dia, false, false, 20);
	cajaHFecha.pack_start(comboDia, false, false, 5);
	cajaHFecha.pack_start(mes, false, false, 5);
	cajaHFecha.pack_start(comboMes, false, false, 5);
	cajaHFecha.pack_start(year, false, false, 5);
	cajaHFecha.pack_start(comboYear, false, false, 5);	// **

	cajaHElegidos.pack_start(ventanaDeslizableFiltrosElegidos, false, false, 20);
	cajaHElegidos.pack_start(ventanaDeslizableInputsElegidos, false, false, 100);	// **

	cajaHBotonesDimensionesHechosElegidos.pack_start(botonRemoverFiltro, false, false, 80);
	cajaHBotonesDimensionesHechosElegidos.pack_start(botonRemoverInput, false, false, 150);	// **

	cajaVertical.pack_start(cajaHModoSeleccion, false, false,18);
	cajaVertical.pack_start(cajaHDimensionesHechos, false, false, 10);
	cajaVertical.pack_start(cajaHFecha, false, false, 10);
	cajaVertical.pack_start(cajaHElegidos, false, false, 10);
	cajaVertical.pack_start(cajaHBotonesDimensionesHechosElegidos, false, false, 0);
}

void FrameDeEleccionDeFiltros::inicializarCombos() {
	comboDimension.set_size_request(100,30);
	comboHecho.set_size_request(80,30);
	comboDia.set_size_request(50,28);
	comboMes.set_size_request(100,28);
	comboYear.set_size_request(80,28);

	for(unsigned int i = 2000; i < 2013; i++)
		comboYear.append_text(Util::intToString(i));

	for(unsigned int i = 0; i < 32; i++)
		comboDia.append_text(Util::intToString(i));
}

void FrameDeEleccionDeFiltros::inicializarHechos() {
	comboHecho.append_text(Util::SNONE);
	comboHecho.append_text(Util::SMAX);
	comboHecho.append_text(Util::SMIN);
	comboHecho.append_text(Util::SAVG);
	comboHecho.append_text(Util::SCOUNT);
	comboHecho.append_text(Util::SSUM);
}

void FrameDeEleccionDeFiltros::inicializarMeses() {
	meses["Ninguno"] = "0";
	meses["Enero"] = "1";
	meses["Febrero"] = "2";
	meses["Marzo"] = "3";
	meses["Abril"] = "4";
	meses["Mayo"] = "5";
	meses["Junio"] = "6";
	meses["Julio"] = "7";
	meses["Agosto"] = "8";
	meses["Septiembre"] = "9";
	meses["Octubre"] = "10";
	meses["Noviembre"] = "11";
	meses["Diciembre"] = "12";

	comboMes.append_text("Ninguno");
	comboMes.append_text("Enero");
	comboMes.append_text("Febrero");
	comboMes.append_text("Marzo");
	comboMes.append_text("Abril");
	comboMes.append_text("Mayo");
	comboMes.append_text("Junio");
	comboMes.append_text("Julio");
	comboMes.append_text("Agosto");
	comboMes.append_text("Septiembre");
	comboMes.append_text("Octubre");
	comboMes.append_text("Noviembre");
	comboMes.append_text("Diciembre");
}

void FrameDeEleccionDeFiltros::inicializarBotones() {
	botonModoEleccion.set_label("Filtro");
	botonModoEleccion.set_size_request(80,30);
	botonAgregarDimension.set_size_request(100,30);
	botonAgregarHecho.set_size_request(100,30);
	botonRemoverInput.set_sensitive(false);
}

void FrameDeEleccionDeFiltros::iniciarLabels() {
	labelModoEleccion.set_markup("<span><b>Modo de elección</b></span>");
	dia.set_text("dia");
	mes.set_text("mes");
	year.set_text("año");
}

void FrameDeEleccionDeFiltros::inicializarVentanasDeslizables() {
	ventanaDeslizableHechos.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	ventanaDeslizableHechos.set_size_request(130, 120);
	referenciaModeloHechos = Gtk::ListStore::create(columnasHechos);
	visorModeloArbolHechos.set_model(referenciaModeloHechos);
	visorModeloArbolHechos.append_column("             Hechos", columnasHechos.idColumna);
	ventanaDeslizableHechos.add(visorModeloArbolHechos);

	ventanaDeslizableDimensiones.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	ventanaDeslizableDimensiones.set_size_request(130, 120);
	referenciaModeloDimensiones = Gtk::ListStore::create(columnasDimensiones);
	visorModeloArbolDimensiones.set_model(referenciaModeloDimensiones);
	visorModeloArbolDimensiones.append_column("     Dimensiones", columnasDimensiones.idColumna);
	ventanaDeslizableDimensiones.add(visorModeloArbolDimensiones);

	ventanaDeslizableFiltrosElegidos.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	ventanaDeslizableFiltrosElegidos.set_size_request(180, 100);
	referenciaModeloFiltrosElegidos = Gtk::ListStore::create(columnasFiltrosElegidos);
	visorModeloArboleFiltrosElegidos.set_model(referenciaModeloFiltrosElegidos);
	visorModeloArboleFiltrosElegidos.append_column("                   Filtros", columnasFiltrosElegidos.idColumna);
	ventanaDeslizableFiltrosElegidos.add(visorModeloArboleFiltrosElegidos);

	ventanaDeslizableInputsElegidos.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	ventanaDeslizableInputsElegidos.set_size_request(180, 100);
	referenciaModeloInputsElegidos = Gtk::ListStore::create(columnasInputsElegidos);
	visorModeloArboleInputsElegidos.set_model(referenciaModeloInputsElegidos);
	visorModeloArboleInputsElegidos.append_column("                    Inputs", columnasInputsElegidos.idColumna);
	ventanaDeslizableInputsElegidos.add(visorModeloArboleInputsElegidos);

}
void FrameDeEleccionDeFiltros::limpiarCombos() {
	referenciaModeloDimensiones->clear();
	referenciaModeloHechos->clear();
	referenciaModeloFiltrosElegidos->clear();
	referenciaModeloInputsElegidos->clear();
	limpiarVectoresDatos();
}

void FrameDeEleccionDeFiltros::limpiarVectoresDatos() {
	valoresFiltrosDimensiones.erase(valoresFiltrosDimensiones.begin(), valoresFiltrosDimensiones.end());
	valoresFiltrosHechos.erase(valoresFiltrosHechos.begin(), valoresFiltrosHechos.end());
	valoresInputsDimensiones.erase(valoresInputsDimensiones.begin(), valoresInputsDimensiones.end());
	valoresInputsHechos.erase(valoresInputsHechos.begin(), valoresInputsHechos.end());
	auxiliarFecha.erase(auxiliarFecha.begin(), auxiliarFecha.end());
}

void FrameDeEleccionDeFiltros::agregarValorAHechos(std::string &dato) {
	Gtk::TreeModel::Row fila = *(referenciaModeloHechos->append());
	fila[columnasHechos.idColumna] = dato.c_str();
}

void FrameDeEleccionDeFiltros::agregarValorADimensiones(std::string &dato) {
	Gtk::TreeModel::Row fila = *(referenciaModeloDimensiones->append());
	size_t pos = dato.find_first_of(Util::MARCAFECHA, 0);

	// si es una fecha
	if(pos != std::string::npos) {
		std::string x = dato.substr(0, pos - 1);
		auxiliarFecha.push_back(x);
		fila[columnasDimensiones.idColumna] = x.c_str();
		return;
	}
	fila[columnasDimensiones.idColumna] = dato.c_str();
}

void FrameDeEleccionDeFiltros::agregarValorAElegidosFiltros(std::string &dato) {
	Gtk::TreeModel::Row fila = *(referenciaModeloFiltrosElegidos->append());
	fila[columnasFiltrosElegidos.idColumna] = dato.c_str();
}

void FrameDeEleccionDeFiltros::agregarValorAElegidosInputs(std::string &dato) {
	Gtk::TreeModel::Row fila = *(referenciaModeloInputsElegidos->append());
	fila[columnasInputsElegidos.idColumna] = dato.c_str();
}

void FrameDeEleccionDeFiltros::on_cambio_boton_modo() {
	if(botonModoEleccion.get_active() == 1) {
		botonModoEleccion.set_label("Input");
		comboHecho.set_sensitive(false);
		comboDimension.set_sensitive(false);
		comboMes.set_sensitive(false);
		comboDia.set_sensitive(false);
		comboYear.set_sensitive(false);
		botonRemoverFiltro.set_sensitive(false);
		botonRemoverInput.set_sensitive(true);
	}
	else {
		botonModoEleccion.set_label("Filtro");
		botonRemoverInput.set_sensitive(false);
		botonRemoverFiltro.set_sensitive(true);
		comboDimension.set_sensitive(true);
		comboMes.set_sensitive(true);
		comboDia.set_sensitive(true);
		comboYear.set_sensitive(true);
		comboHecho.set_sensitive(true);
	}
	//
}

void FrameDeEleccionDeFiltros::on_quitar_input() {
	Gtk::TreeModel::Row filaModelo;
	std::string borrado;
	int pos;

	Glib::RefPtr<Gtk::TreeSelection> filaElegida = visorModeloArboleInputsElegidos.get_selection();
	Gtk::TreeModel::iterator iterador = filaElegida->get_selected();

	if(iterador) {
		filaModelo = *iterador;
		borrado= filaModelo[columnasInputsElegidos.idColumna];

		if(botonModoEleccion.get_active() == 1) { // modo input
			// debo agregarlo a la lista correcta(hecho o dimension) y borrarlo del vector coorrecto

			if((pos = hayValorEnVector(valoresInputsDimensiones, borrado)) >= 0) {	// INPUT DIMENSION
				valoresInputsDimensiones.erase(valoresInputsDimensiones.begin() + pos);

				agregarValorADimensiones(borrado);
			}	// supongo q si no esta en los hecho deberAAA estar en las dimensiones
			else {	// INPUT HECHO
				pos = hayValorEnVector(valoresInputsHechos, borrado);
				valoresInputsHechos.erase(valoresInputsHechos.begin() + pos);

				agregarValorAHechos(borrado);
			}
			removerValorDeVentanaDeslizable(referenciaModeloInputsElegidos, columnasInputsElegidos, borrado);
		}
	}
}

void FrameDeEleccionDeFiltros::on_quitar_filtro() {
	Gtk::TreeModel::Row filaModelo;
	std::string borrado;
	std::string borradoSinPuntos;
	int pos;

	Glib::RefPtr<Gtk::TreeSelection> filaElegida = visorModeloArboleFiltrosElegidos.get_selection();
	Gtk::TreeModel::iterator iterador = filaElegida->get_selected();

	if(iterador) {
		filaModelo = *iterador;
		borrado= filaModelo[columnasFiltrosElegidos.idColumna];
		borradoSinPuntos = borrado.substr(0, borrado.find_first_of(Util::DOSPUNTOS, 0));

		if(botonModoEleccion.get_active() == 0) { // modo filtro
			// debo agregarlo a la lista correcta(hecho o dimension) y borrarlo del vector coorrecto

			if((pos = hayValorEnVector(valoresFiltrosHechos, borrado)) >= 0) {	// FILTRO hecho
				valoresFiltrosHechos.erase(valoresFiltrosHechos.begin() + pos);

				agregarValorAHechos(borradoSinPuntos);
			}
			else {	// FILLTRO dimension
				pos = hayValorEnVector(valoresFiltrosDimensiones, borrado);
				valoresFiltrosDimensiones.erase(valoresFiltrosDimensiones.begin() + pos);

				agregarValorADimensiones(borradoSinPuntos);
			}

			removerValorDeVentanaDeslizable(referenciaModeloFiltrosElegidos, columnasFiltrosElegidos, borrado);
		}
	}
}

void FrameDeEleccionDeFiltros::removerValorDeVentanaDeslizable(refListore &ref, ModeloDeColumnasU& col, std::string&dato) {
	Gtk::TreeModel::Row fila;
	std::string deFila;

	type_children children = ref->children();
	type_children::iterator iter = children.begin();

	for(; iter != children.end(); ++iter) {
		fila = *iter;
		deFila = fila[col.idColumna];
		if(deFila.compare(dato) == 0)	// si o si estara el dato
			break;
	}

	ref->erase(iter);
}

void FrameDeEleccionDeFiltros::on_boton_agregar_hecho() {
	Gtk::TreeModel::Row filaModelo;
	std::string elegido;

	Glib::RefPtr<Gtk::TreeSelection> filaElegida = visorModeloArbolHechos.get_selection();
	Gtk::TreeModel::iterator iterador = filaElegida->get_selected();

	if(iterador) {
		filaModelo = *iterador;
		elegido = filaModelo[columnasHechos.idColumna];

		// si esta en modo input
		if(botonModoEleccion.get_active() == 1) {
			// se agrega ala ventanadslizable de inputs elegido
			agregarValorAElegidosInputs(elegido);
			valoresInputsHechos.push_back(elegido);
			removerValorDeVentanaDeslizable(referenciaModeloHechos, columnasHechos, elegido);
		}
		else { // modo filtro
			std::string agregacion = comboHecho.get_active_text();

			if(!agregacion.empty()) {
				removerValorDeVentanaDeslizable(referenciaModeloHechos, columnasHechos, elegido);
				elegido.append(1, Util::DOSPUNTOS);
				elegido.append(1, Util::SEPARADORFILECONSULTA);
				elegido.append(agregacion);
				agregarValorAElegidosFiltros(elegido);
				valoresFiltrosHechos.push_back(elegido);
			}
		}
	}
}

void FrameDeEleccionDeFiltros::on_boton_agregar_dimension() {
	Gtk::TreeModel::Row filaModelo;
	std::string elegido;

	Glib::RefPtr<Gtk::TreeSelection> filaElegida = visorModeloArbolDimensiones.get_selection();
	Gtk::TreeModel::iterator iterador = filaElegida->get_selected();

	if(iterador) {
		filaModelo = *iterador;
		elegido = filaModelo[columnasDimensiones.idColumna];

		// si esta en modo input
		if(botonModoEleccion.get_active() == 1) {
			// se agrega ala ventanadslizable de inputs elegido
			agregarValorAElegidosInputs(elegido);

			valoresInputsDimensiones.push_back(elegido);
			removerValorDeVentanaDeslizable(referenciaModeloDimensiones, columnasDimensiones, elegido);
		}
		else {	// modo filtro
			if(hayValorEnVector(auxiliarFecha, elegido) != -1) {	// si era un tipo fecha
				std::string dia = comboDia.get_active_text();
				std::string mes = comboMes.get_active_text();
				std::string anio = comboYear.get_active_text();

				if(!dia.empty() && !mes.empty() && !anio.empty()) {
					removerValorDeVentanaDeslizable(referenciaModeloDimensiones, columnasDimensiones, elegido);
					elegido.append(1, Util::DOSPUNTOS);
					elegido.append(1, Util::SEPARADORFILECONSULTA);
					elegido.append(anio);
					elegido.append(1, Util::SEPARADORFECHA);
					elegido.append(mes);
					elegido.append(1, Util::SEPARADORFECHA);
					elegido.append(dia);
					agregarValorAElegidosFiltros(elegido);
					valoresFiltrosDimensiones.push_back(elegido);
				}
			}
			else {	// no es fechaaaaaa
				std::string agregacion = comboDimension.get_active_text();
				if(!agregacion.empty()) {
					removerValorDeVentanaDeslizable(referenciaModeloDimensiones, columnasDimensiones, elegido);
					elegido.append(1, Util::DOSPUNTOS);
					elegido.append(1, Util::SEPARADORFILECONSULTA);
					elegido.append(agregacion);
					agregarValorAElegidosFiltros(elegido);
					valoresFiltrosDimensiones.push_back(elegido);
				}
			}
		}
	}
}

void FrameDeEleccionDeFiltros::conectarManejadoresDeEvento() {
	botonModoEleccion.signal_clicked().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_cambio_boton_modo));
	botonAgregarHecho.signal_clicked().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_boton_agregar_hecho));
	botonAgregarDimension.signal_clicked().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_boton_agregar_dimension));
	botonRemoverInput.signal_clicked().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_quitar_input));
	botonRemoverFiltro.signal_clicked().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_quitar_filtro));

	Glib::RefPtr<Gtk::TreeSelection> refDim = visorModeloArbolDimensiones.get_selection();
	refDim->signal_changed().connect(sigc::mem_fun(*this, &FrameDeEleccionDeFiltros::on_cambios_dimension));
}

/******************************************************/
/*
void setCliente(CLiente cliente) {
	this->cliente = cliente;
}
*/
/******************************************************/

void FrameDeEleccionDeFiltros::on_cambios_dimension() {
	Glib::RefPtr<Gtk::TreeSelection> fila = visorModeloArbolDimensiones.get_selection();
	Gtk::TreeModel::iterator iter = fila->get_selected();
	std::string entradaDimension;

	if(iter) {
		Gtk::TreeModel::Row fila = *iter;
		entradaDimension = fila[columnasDimensiones.idColumna];
		/***************************/
		/*
		 * AQUI SE LLAMA AL CLIENTE Y SE LE PIDE COSAS
		 *
		 *	jose|pedro|marcos|miguel
		 *
		 */
		//std::string respuesta;
		/*
		 *  PARSEAR Y LLENAR ELL COMBOBOX
		 *
		 */
		//comboDimension.append_text(respuesta);
		comboDimension.clear_items();
		comboDimension.append_text("HOLA");
		comboDimension.append_text("!&/(");
		/*
		 * for () llenar todo
		 */

	}
}

int FrameDeEleccionDeFiltros::hayValorEnVector(std::vector<std::string>& vec, std::string&valor) {
	unsigned int posicion = 0;
	bool encontro = false;

	for( ; posicion < vec.size(); posicion++)
		if(vec[posicion].compare(valor) == 0) {
			encontro = true;
			break;
		}

	if(encontro)
		return posicion;
	return -1;
}

FrameDeEleccionDeFiltros::~FrameDeEleccionDeFiltros() {}



std::vector<std::string>& FrameDeEleccionDeFiltros::getValoresFiltrosDimensiones() {
	return valoresFiltrosDimensiones;
}

std::vector<std::string> &FrameDeEleccionDeFiltros::getValoresFiltrosHechos() {
	return valoresFiltrosHechos;
}
std::vector<std::string> &FrameDeEleccionDeFiltros::getValoresInputsDimensiones() {
	return valoresInputsDimensiones;
}
std::vector<std::string> &FrameDeEleccionDeFiltros::getValoresInputsHechos() {
	return valoresInputsHechos;
}
